package com.thrd.basicframework.bean;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;

import com.thrd.basicframework.R;
import com.thrd.basicframework.ui.defaultview.LoadingState;
import com.thrd.basicframework.ui.defaultview.XHLoadingView;


public abstract class BaseFragment extends Fragment {
    private   String TAG =getClass().getCanonicalName() ;
//    protected final String TAG=this.getClass().getSimpleName();

    private XHLoadingView mContentView;
    private Context mContext;



    private boolean isCanLoad=false;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
//        mContentView = inflater.inflate(setLayoutResourceID(), container, false);
//        setUpView(mContentView);

        if (null != mContentView) {
            ViewGroup parent = (ViewGroup) mContentView.getParent();
            if (null != parent) {
                parent.removeView(mContentView);
            }
        } else {
            mContentView=new XHLoadingView(getMContext());
            mContentView.withLoadEmptyText("≥﹏≤ , 啥也木有 !").withEmptyIcon(R.mipmap.icon_ni_data).withBtnEmptyEnnable(false)
                    .withErrorIco(R.mipmap.icon_failed_load).withLoadErrorText("(῀( ˙᷄ỏ˙᷅ )῀)ᵒᵐᵍᵎᵎᵎ,我家程序猿跑路了 !").withBtnErrorText("臭狗屎!!!")
                    .withLoadNoNetworkText("你挡着信号啦o(￣ヘ￣o)☞ᗒᗒ 你走").withNoNetIcon(R.mipmap.icon_service_error).withBtnNoNetText("网弄好了，重试")
                    .withLoadingIcon(R.drawable.loading).withLoadingText("加载中...").withOnRetryListener(new XHLoadingView.OnRetryListener() {
                @Override
                public void onRetry() {
                    onFragmentFirstVisible();
                }
            }).build();
            mContentView.setState(LoadingState.STATE_LOADING);
            mContentView.setContentView(inflater.inflate(setLayoutResourceID(), null));
            setUpView(mContentView.getContentView());
            setUpData();// 控件初始化
        }

        return mContentView;
    }
    //onViewStateRestored


    @Override
    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
        super.onViewStateRestored(savedInstanceState);
        onRecoveryBundle(savedInstanceState);
    }

    protected void onRecoveryBundle(Bundle savedInstanceState){

    }

    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        this.mContext=context;
    }


    @Override
    public void onAttach(@NonNull Activity activity) {
        super.onAttach(activity);
        this.mContext=activity;
    }

    /**
     * 此方法用于返回Fragment设置ContentView的布局文件资源ID * * @return 布局文件资源ID
     */
    protected abstract int setLayoutResourceID();

    /**
     * 一些View的相关操作
     */
    protected abstract void setUpView(View mContentView);

    /**
     * 一些Data的相关操作
     */
    protected abstract void setUpData();



    public XHLoadingView getContentView() {
        return mContentView;
    }

    public Context getMContext() {
        if(isAdded()){
            return mContext;
        }else{
            return getContext();
        }

    }


    private boolean mIsFirstVisible = true;

    private boolean isViewCreated = false;

    private boolean currentVisibleState = false;

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        //走这里分发可见状态情况有两种，1. 已缓存的 Fragment 被展示的时候 2. 当前 Fragment 由可见变成不可见的状态时
        // 对于默认 tab 和 间隔 checked tab 需要等到 isViewCreated = true 后才可以通过此通知用户可见，
        // 这种情况下第一次可见不是在这里通知 因为 isViewCreated = false 成立，可见状态在 onActivityCreated 中分发
        // 对于非默认 tab，View 创建完成  isViewCreated =  true 成立，走这里分发可见状态，mIsFirstVisible 此时还为 false  所以第一次可见状态也将通过这里分发
        if (isViewCreated){
            if (isVisibleToUser && !currentVisibleState) {
                dispatchUserVisibleHint(true);
            }else if (!isVisibleToUser && currentVisibleState){
                dispatchUserVisibleHint(false);
            }
        }

    }

    /**
     * 统一处理 显示隐藏  做两件事
     * 设置当前 Fragment 可见状态 负责在对应的状态调用第一次可见和可见状态，不可见状态函数
     * @param visible
     */
    public void dispatchUserVisibleHint(boolean visible) {

        currentVisibleState = visible;

        if (visible) {
            if (mIsFirstVisible) {
                mIsFirstVisible = false;
                onFragmentFirstVisible();
            }
            onFragmentResume();
        }else {
            onFragmentPause();
        }
    }

    /**
     * 该方法与 setUserVisibleHint 对应，调用时机是 show，hide 控制 Fragment 隐藏的时候，
     * 注意的是，只有当 Fragment 被创建后再次隐藏显示的时候才会调用，第一次 show 的时候是不会回调的。
     */
    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        if (hidden){
            dispatchUserVisibleHint(false);
        }else {
            dispatchUserVisibleHint(true);
        }
    }


    /**
     * 对用户第一次可见
     */
    public void onFragmentFirstVisible(){
        //mContentView.setState(LoadingState.STATE_LOADING);
    }

    /**
     *   对用户可见
     */
    public void onFragmentResume(){
//        if(mFrameLayoutSlide!=null)
//            mFrameLayoutSlide.setSlide(true);
    }

    /**
     *  对用户不可见
     */
    public void onFragmentPause(){
//        if(mFrameLayoutSlide!=null)
//            mFrameLayoutSlide.setSlide(false);

    }

    /**
     * 判断是否可见
     * @return
     */
    public boolean isCurrentVisibleState() {
        return currentVisibleState;
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        //当 View 被销毁的时候我们需要重新设置 isViewCreated mIsFirstVisible 的状态
        isViewCreated = false;
        mIsFirstVisible = true;
    }

    /**
     * 需要再 onResume 中通知用户可见状态的情况是在当前页面再次可见的状态 !mIsFirstVisible 可以保证这一点，
     * 而当前页面 Activity 可见时所有缓存的 Fragment 都会回调 onResume
     * 所以我们需要区分那个Fragment 位于可见状态
     * (!isHidden() && !currentVisibleState && getUserVisibleHint()）可条件可以判定哪个 Fragment 位于可见状态
     */
    @Override
    public void onResume() {
        super.onResume();
        Log.e(TAG,"onResume");
        if (!mIsFirstVisible){
            if (!isHidden() && !currentVisibleState && getUserVisibleHint()){
                dispatchUserVisibleHint(true);
            }
        }

    }
    /**
     * 当用户进入其他界面的时候所有的缓存的 Fragment 都会 onPause
     * 但是我们想要知道只是当前可见的的 Fragment 不可见状态，
     * currentVisibleState && getUserVisibleHint() 能够限定是当前可见的 Fragment
     */
    @Override
    public void onPause() {
        super.onPause();
        Log.e(TAG,"onPause");
        if (currentVisibleState && getUserVisibleHint()){
            dispatchUserVisibleHint(false);
        }
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.e(TAG,"onStop");
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.e(TAG,"onStart");
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        // 将 View 创建完成标志位设为 true
        isViewCreated = true;
        // 默认 Tab getUserVisibleHint() = true !isHidden() = true
        // 对于非默认 tab 或者非默认显示的 Fragment 在该生命周期中只做了 isViewCreated 标志位设置 可见状态将不会在这里分发
        if (!isHidden() && getUserVisibleHint()){
            dispatchUserVisibleHint(true);
        }

    }
    private boolean isAnimentionType=false;





    /**
     * 数据加载
     */
    protected void loadData(){
        //showLoad();
        mContentView.setState(LoadingState.STATE_LOADING);
    }

    /**
     * 是否可以加载数据  代表布局已经初始化完成
     * @return
     */
    public boolean isCanLoad() {
        return isCanLoad;
    }

    public void setCanLoad(boolean canLoad) {
        isCanLoad = canLoad;
    }

//    private int timeAdd=0;
//    /**
//     * 定时器
//     */
//    public void timerDistribution(){
//        int typeTimed=onTimedTypeCallback(++timeAdd);
//        if(typeTimed>0){
//            onTimedCallback(typeTimed);
//        }
//        if(timeAdd>Integer.MAX_VALUE-1000){
//            timeAdd=0;
//        }
//    }
//    protected void onTimedCallback(int type){
//
//    }
//
//    protected int onTimedTypeCallback(int timeAdd){
//        return -1;
//    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        if(mContentView!=null){
            mContentView=null;
        }
        mContext=null;
        System.gc();
    }
}
